
/**************** 类和对象 中 ****************/
#include<iostream>
#include<cstdlib>
#include<cstring>
using namespace std;

#if 0
class Stack
{
public:
//构造函数，与类名相同，无返回值，不需要写void
    Stack()
    {
        cout << "Stack()" << endl;
        _arr = (int*)malloc(sizeof(int) * 100);
        _top = 0, _capacity = 100;
    }

    Stack(int n)
    {
        cout << "Stack(int n)" << endl;
        _arr = (int*)malloc(sizeof(int) * n);
        _top = 0, _capacity = n;
    }

    void Print()
    {
        printf("_arr: %p, _top: %d, _capacity: %d\n", _arr, _top, _capacity);
    }
//析构函数，与类名相同，无返回值，不需要写void
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_arr);
        _top = _capacity = 0;
    }
private:
    int* _arr;
    int _top;
    int _capacity;
};


int main()
{
    Stack st1;
    st1.Print();

    Stack st2(999);
    st2.Print();

    void func();
    func();
    return 0;
}
#endif

// int main()
// {
//     void func();
//     func();
//     return 0;
// }
// void func()
// {
//     cout << "HHH" << endl;
// }


// class Stack
// {
// public:
// //构造函数，与类名相同，无返回值，不需要写void
//     void Print()
//     {
//         printf("_arr: %p, _top: %d, _capacity: %d\n", _arr, _top, _capacity);
//     }
// private:
//     int* _arr;
//     int _top;
//     int _capacity;
// };

// int main()
// {
//     Stack st1;		// 调用Stack()
//     st1.Print();

//     Stack st2(999); // 调用Stack(int n)
//     st2.Print();
//     return 0;
// }

// class A
// {
// public:
//     // 无参构造函数
//     A()
//     {
//         cout << "A()" << endl;
//         _t = 0;
//     }
// private:
//     int _t;
// };

// class C
// {
// public:
//     // 全缺省构造函数
//     C(int c = 999)
//     {
//         cout << "C(int c = 999)" << endl;
//         _t1 = c;
//     }
// private:
//     int _t1;
// };

// class B
// {
// public:
//     void Print()
//     {
//         printf("_b: %d\n", _b);
//     }
// private:
//     // 我们没有写B的构造函数，编译器会自动实现
//     A _a;   // 自定义类型，会调用其默认构造函数
//     int _b; // 不做处理
//     C _c;   // 自定义类型，会调用其默认构造函数
// };

// int main()
// {
//     B b;
//     b.Print();
//     return 0;
// }

// class A
// {
// private:
//     int _a;
// };

// class B
// {
// private:
//     int _b;
//     A _a;
// };
// int main()
// {
//     B b;
//     return 0;
// }

// class Time
// {
// public:
//     // Time(int h = 10, int m = 24, int s = 0)
//     // {
//     //     _hour = h;
//     //     _minute = m;
//     //     _second = s;
//     // }
// private:
//     int _hour = 1;
//     int _minute = 1;
//     int _second = 1;
// };

// class Date
// {
// public:

// private:
//     int _year = 2025;
//     int _month = 9;
//     int _day = 10;
//     Time _t;
// };

// int main()
// {
//     // Date d;
//     Time t;
//     return 0;
// }

// class Stack
// {
// public:
// //构造函数
//     Stack(int n = 10)
//     {
//         cout << "Stack(int n = 10)" << endl;
//         _arr = (int*)malloc(sizeof(int) * n);
//         _top = 0, _capacity = 100;
//     }

// //析构函数
//     ~Stack()
//     {
//         cout << "~Stack()" << endl;
//         free(_arr);
//         _arr = nullptr;
//         _top = _capacity = 0;
//     }
// private:
//     int* _arr;
//     int _top;
//     int _capacity;
// };

// class Test
// {
// public:
//     Test()
//     {
//         cout << "Test()" << endl;
//         // _st.Stack();
//     }
// private:
//     Stack _st;
// };

// int main()
// {
//     Test t; // Test没写构造跟析构，其自定义类型成员变量_st会调用Stack类的默认构造和析构
//     return 0;
// }

// class Stack
// {
// public:
// //构造函数，与类名相同，无返回值，不需要写void
//     Stack()
//     {
//         cout << "Stack()" << endl;
//         _arr = (int*)malloc(sizeof(int) * 100);
//         _top = 0, _capacity = 100;
//     }

//     Stack(int n)
//     {
//         cout << "Stack(int n)" << endl;
//         _arr = (int*)malloc(sizeof(int) * n);
//         _top = 0, _capacity = n;
//     }

//     Stack(int n, int cnt)
//     {
//         cout << "Stack(int n, int cnt)" << endl;
//         _arr = (int*)malloc(sizeof(int) * n * cnt);
//         _top = 0, _capacity = n * cnt;
//     }

//     void Print()
//     {
//         printf("_arr: %p, _top: %d, _capacity: %d\n", _arr, _top, _capacity);
//     }
// private:
//     int* _arr;
//     int _top;
//     int _capacity;
// };

// int main()
// {
//     Stack st1;		// 调用Stack()
//     st1.Print();

//     Stack st2(999); // 调用Stack(int n)
//     st2.Print();

//     Stack st3(12, 2);   // 调用Stack(int n, int cnt)
//     st3.Print();
//     st3.Stack();
//     return 0;
// }

// class Date
// {
// public:
//     Date(int year = 2025, int month = 9, int day = 10)
//     {
//         cout << "Date(int year = 2025, int month = 9, int day = 10)" << endl;
//         _year = year;
//         _month = month;
//         _day = day;
//     }
//     // // Date(Date d)    // 错误写法：编译报错，会引发无穷递归 
//     // Date(Date& d)   // 正确写法
//     // {
//     //     cout << "Date(const Date& d)" << endl;
//     //     _year = d._year;
//     //     _month = d._month;
//     //     _day = d._day;
//     // }

//     void Print()
//     {
//         printf("%d-%d-%d\n", _year, _month, _day);
//     }
// private:
//     int _year;
//     int _month;
//     int _day;
// };
// int main()
// {
//     Date d1(2000, 1, 1);
//     Print();
//     Date d2(d1);    //d2 拷贝 d1
//     d2.Print();

//     Date d3 = d1;   //这种写法也是拷贝构造。d3 拷贝 d1
//     d3.Print();

//     // // 下面的写法不是拷贝构造：
//     // Date d4;    //调用默认构造
//     // d4 = d1;    //赋值重载，接下来会讲
//     return 0;
// }

// class Stack
// {
// public:
//     Stack(int n = 100)
//     {
//         cout << "Stack(int n = 100)" << endl;
//         _arr = (int*)malloc(sizeof(int) * n);
//         _top = 0, _capacity = n;
//     }

//     ~Stack()
//     {
//         cout << "~Stack()" << endl;
//         free(_arr);
//         _top = _capacity = 0;
//     }

//     Stack(const Stack& st)
//     {
//         cout << "Stack(const Stack& st)" << endl;
//         _arr = (int*)malloc(sizeof(int) * st._capacity);
//         _top = st._top;
//         _capacity = st._capacity;
//         for(int i = 0; i < st._top; i++)
//             _arr[i] = st._arr[i];
//     }
//     void Print()
//     {
//         printf("_arr: %p, _top: %d, _capacity: %d\n", _arr, _top, _capacity);
//     }
// private:
//     int* _arr;
//     int _top;
//     int _capacity;
// };

// int main()
// {
//     Stack st1;
//     st1.Print();
//     Stack st2 = st1;
//     st2.Print();
//     return 0;
// }


// class Date
// {
// public:
//     Date(int y = 2025, int m = 9, int d = 11)
//     {
//         _year = y, _month = m, _day = d;
//     }

//     // 比较类的大小. 用d1表示当前类
//     // d1 > d2返回true
//     bool greater(const Date& d2)
//     {
//         if (_year != d2._year) return _year > d2._year;
//         if (_month != d2._month) return _month > d2._month;
//         return _day > d2._day;
//     }
//     // d1 == d2返回true
//     bool equal(const Date& d2)
//     {
//         return _day == d2._day && _year == d2._year && _month == d2._month;
//     }

//     // d1 < d2返回true
//     bool lesser(const Date& d2)
//     {
//         if (_year != d2._year) return _year < d2._year;
//         if (_month != d2._month) return _month < d2._month;
//         return _day < d2._day;
//     }
// private:
//     int _year;
//     int _month;
//     int _day;
// };

// class Date
// {
// public:
//     Date(int y = 2025, int m = 9, int d = 11)
//     {
//         _year = y, _month = m, _day = d;
//     }

//     // 运算符重载，函数名为：operator后面接上运算符
//     // 比较类的大小. 用d1表示当前类
//     // d1 > d2返回true
//     bool operator> (const Date& d2)
//     {
//         cout << "bool operator> (const Date& d2)" << endl;
//         if (_year != d2._year) return _year > d2._year;
//         if (_month != d2._month) return _month > d2._month;
//         return _day > d2._day;
//     }
//     // d1 == d2返回true
//     bool operator== (const Date& d2)
//     {
//         cout << "bool operator== (const Date& d2)" << endl;
//         return _day == d2._day && _year == d2._year && _month == d2._month;
//     }

//     // d1 < d2返回true
//     bool operator< (const Date& d2)
//     {
//         cout << "bool operator< (const Date& d2)" << endl;
//         if (_year != d2._year) return _year < d2._year;
//         if (_month != d2._month) return _month < d2._month;
//         return _day < d2._day;
//     }
// private:
//     int _year;
//     int _month;
//     int _day;
// };

// int main()
// {
//     Date d1(2025, 9, 10);
//     Date d2(2025, 9, 11);

//     // 这里编译器会把 d1 > d2 转换成 d1.operator>(d2)
//     if(d1 > d2) cout << "d1 > d2" << endl;

//     // 这里同上，将d1 == d2转换成d1.operator==(d2)
//     if(d1 == d2) cout << "d1 == d2" << endl;

//     // d1.operator<(d2)
//     if(d1 < d2) cout << "d1 < d2" << endl;
//     return 0;
// }


// struct A
// {
// public:
//     int operator*()
//     {
//         return this->_a;
//     }
//     int _a;
// };

// int operator*(A& pa)
// {
//     return pa._a;
// }

// int main()
// {
//     A a1;
//     int t = *a1;
//     // cout << t;
//     return 0;
// }

// class T
// {
// public:
//     void func()
//     {
//         cout << "void func()" << endl;
//     }
// };

// typedef void (*ff) ();
// typedef void (T::*ff) ();

// int main()
// {
//     T t;
//     return 0;
// }


// class Date
// {
// public:
//     Date(int y = 2025, int m = 9, int d = 11)
//     {
//         _year = y, _month = m, _day = d;
//     }
//     // d1 == d2返回true
//     bool operator== (const Date& d2)
//     {
//         cout << "bool operator== (const Date& d2)" << endl;
//         return _day == d2._day && _year == d2._year && _month == d2._month;
//     }
//     friend bool operator== (const Date& d1, const Date& d2);
// private:
//     int _year;
//     int _month;
//     int _day;
// };

// bool operator== (const Date& d1, const Date& d2)
// {
//     cout << "bool operator== (const Date& d1, const Date& d2)" << endl;
//     return d1._day == d2._day && d1._year == d2._year && d1._month == d2._month;
// }
// int main()
// {
//     Date d1(2025, 9, 10);
//     Date d2(2025, 9, 11);

//     d1 == d2;

//     return 0;
// }

// class Date
// {
// public:
//     Date(int y = 2025, int m = 9, int d = 11)
//     {
//         _year = y, _month = m, _day = d;
//     }

//     Date(const Date& d)
//     {
//         cout << "Date (const Date& d)" << endl;
//         _year = d._year, _month = d._month, _day = d._day;
//     }
//     // 改为Date&, 若为Date会调用不必要的拷贝构造
//     Date operator= (const Date& d)
//     {
//         cout << "Date operator= (const Date& d)" << endl;
//         _year = d._year, _month = d._month, _day = d._day;
//         return *this;
//     }
//     void Print()
//     {
//         printf("%d-%d-%d\n", _year, _month, _day);
//     }
// private:
//     int _year;
//     int _month;
//     int _day;
// };

// Date& func()
// {
//     static Date d(2022, 10, 10);
//     return d;
// }
// int main()
// {
//     Date d1 = func();
//     //printf("-----------\n");
//     d1.Print();
//     return 0;
// }


// class A
// {
// public:
//     A& operator=(const A& a1)
//     {
//         cout << "A& operator=(const A& a1)" << endl;
//         _a = a1._a;
//         return *this;
//     }
// private:
//     int _a = 1;
// };

// class T
// {
// public:
//     T(int x = 1)
//     {
//         _t = x;
//     }
// private:
//     int _t;
//     A _aa;
// };

// int main()
// {
//     T t1(222);
//     T t2;
//     t2 = t1;
//     return 0;
// }
